#include <iostream>
#include <stdexcept>

template <typename T, size_t Capacity = 100>
class MyStack {
private:
    T data[Capacity];  // 存储栈元素的数组
    size_t topIndex;   // 栈顶索引

public:
    // 构造函数
    MyStack() : topIndex(0) {}

    // 入栈操作
    void push(const T& item) {
        if (isFull()) {
            throw std::overflow_error("栈已满，无法入栈");
        }
        data[topIndex++] = item;
    }

    // 出栈操作
    T pop() {
        if (isEmpty()) {
            throw std::underflow_error("栈为空，无法出栈");
        }
        return data[--topIndex];
    }

    // 查看栈顶元素（不删除）
    T peek() const {
        if (isEmpty()) {
            throw std::underflow_error("栈为空，无法查看栈顶元素");
        }
        return data[topIndex - 1];
    }

    // 检查栈是否为空
    bool isEmpty() const {
        return topIndex == 0;
    }

    // 检查栈是否已满
    bool isFull() const {
        return topIndex == Capacity;
    }

    // 获取栈当前元素数量
    size_t size() const {
        return topIndex;
    }

    // 获取栈容量
    size_t capacity() const {
        return Capacity;
    }

    // 清空栈
    void clear() {
        topIndex = 0;
    }
};

// 测试代码
int main() {
    MyStack<int, 5> stack;  // 创建一个容量为5的整型栈

    // 测试入栈
    stack.push(10);
    stack.push(20);
    stack.push(30);
    std::cout << "栈顶元素: " << stack.peek() << std::endl;
    std::cout << "栈大小: " << stack.size() << std::endl;

    // 测试出栈
    std::cout << "出栈元素: " << stack.pop() << std::endl;
    std::cout << "出栈后栈顶元素: " << stack.peek() << std::endl;

    // 测试栈满的情况
    stack.push(40);
    stack.push(50);
    stack.push(60);  // 此时栈已满

    try {
        stack.push(70);
    } catch (const std::overflow_error& e) {
        std::cout << "错误: " << e.what() << std::endl;
    }

    // 测试清空栈
    stack.clear();
    std::cout << "清空后栈大小: " << stack.size() << std::endl;

    return 0;
}